package com.winning.ds.common.util.excel;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class UploadTransData {
	/**
	 * 字典转换
	 * @param dictTransMaps 所有需要进行转换的字典集合   列名->(值代码->值名称)
	 * @param valueList  每一行的数据集合   
	 * @param columnsName 列名称集合
	 */
	 
	public List<String> sjzh(Map<String,ExcelDictionary>dictTransMaps, List<String>valueList, List columnsName){
		System.out.println("----------->字典转换!");
		for(Entry <String,ExcelDictionary>entry:dictTransMaps.entrySet()){
			//获取当前列
			String column = entry.getKey();
			//获取当前列所对应的字典项
			ExcelDictionary dict = entry.getValue();
			//获取有效值
			Map <String,String>dictMap = dict.getYxz();
			//获取当前列在Excel里所处的位置
			int index = columnsName.indexOf(column.trim());
			String value = valueList.get(index);
			if(!("".equals(value))){
				if(dict.getIsMult().equals("N")){
					//根据字典对当前列进行转化（如果KEY值里面有当前列的值，那么转换为对应的VALUE值，反之一样）
					if(dictMap.containsKey(valueList.get(index))){
						valueList.set(index, dictMap.get(value));
					}else{
						//将字典项里面的所有VALUE值取出来进行校验
						for(Entry<String,String>en:dictMap.entrySet()){
							if(en.getValue().equals(value)){
								valueList.set(index, en.getKey());
							}else{
								continue;
							}
						}
					}
				}else{
					String []values = new String[]{};
					if(value.contains("/")){
						values = value.split("/");
					}else if(value.contains(",")){
						values = value.split(",");
					}
					List yxz = new ArrayList();
					for(int j = 0; j<values.length; j++){
						value = values[j];
						if(dictMap.containsKey(value)){
							yxz.add(dictMap.get(value));
						}else{
							//将字典项里面的所有VALUE值取出来进行校验
							for(Entry<String,String>en:dictMap.entrySet()){
								if(en.getValue().equals(value)){
									//valueList.set(index, en.getKey());
									yxz.add(en.getKey());
								}else{
									continue;
								}
							}
						}
					}
					valueList.set(index, yxz.toString().substring(1, yxz.toString().length()-1).replace(",", "/"));
				}
			}else{
				continue;
			}
			
		}
		return valueList;
	}
	/**
	 * 数据校验
	 * @param dictMaps 所有的字典项集合   列名-》字典对象
	 * @param //valueLists 每一行的数据集合
	 * @param //columnsNane 所有的列名
	 */
	public List <Integer>sjjy(Map<String,ExcelDictionary>dictMaps,List<String>valueList,List columnsName){
		//校验是否通过
		System.out.println("----------->字典校验!");
		List <Integer>cellIndexs = new ArrayList<Integer>();
		for(Entry<String,ExcelDictionary>entry:dictMaps.entrySet()){
			//某一列开始校验
			String column = entry.getKey();
			//System.out.println(column);      
			//获取某一列的字典对象
			ExcelDictionary dict = dictMaps.get(column);
			//获取某一列的有效值
			Map<String,String> dictMap = dict.getYxz();
			//获取某一列在列集合中的位置，对位置数进行统计
			int index = columnsName.indexOf(column);
			if(index < 0){
			  continue;
      }
			//在数据集合中根据index取出当前列的数据进行校验
			String value = valueList.get(index);
			//System.out.println(value);
			if(!("").equals(value) && value !=null){
				value = value.trim();
			}
			//当某一列不为多选时校验
			if(dict.getIsMult().equals("N")){
				//判断在字典有效值中是否存在Key值或者Value值进行判断是否校验通过
				if(dictMap.containsKey(value)){
					continue;
				}else if(dictMap.containsValue(value)){
					continue;
				}else if(dict.getIsNull().equals("Y")&&((valueList.get(index))==null || ("").equals(valueList.get(index)))){
					//当某一列为可以为空，并且当前列的数据为NULL或者空的时候校验通过
					continue;
				}else{
					cellIndexs.add(index+1);
				}
			}else{//当某一列为多选是所进行的校验
				if((valueList.get(index))!=null && !("").equals(valueList.get(index))){
					String []values = value.split("/");
					for(int j = 0;j <values.length; j++){    
						value = values[j];
						//判断在字典有效值中是否存在Key值或者Value值进行判断是否校验通过
						if(dictMap.containsKey(value)){
							continue;
						}else if(dictMap.containsValue(value)){
							continue;
						}else if(dict.getIsNull().equals("Y")&&((valueList.get(index))==null && ("").equals(valueList.get(index)))){
							//当某一列为可以为空，并且当前列的数据为NULL或者空的时候校验通过
							continue;
						}
					}
				}else if(dict.getIsNull().equals("N")&&(valueList.get(index))==null && ("").equals(valueList.get(index))){
					cellIndexs.add(index+1);
				}else{
					continue;
				}
			}
		}
		return cellIndexs;
	}
	
	/**
	 * 对字段的类型以及长度进行校验，返回每行失败数据的列数
	 * @param valueList  每行的数据
	 * @param columnLengthMaps  字段类型长度字典
	 * @param columnsName  列名集合
	 * @return
	 */
	public List<Integer> typeLenthJy(List<String> valueList,Map<String,Map<String,Object>>columnLengthMaps,List<String> columnsName){
		List <Integer>legthIndex = new ArrayList<Integer>();
		Map<String,Object> columnLengthMap = new HashMap<String,Object>();
		for(int i=0;i<columnsName.size();i++){
			String name = columnsName.get(i).toLowerCase();
			String value = valueList.get(i);
			columnLengthMap = columnLengthMaps.get(name);
			if (columnLengthMap == null) {
				continue;
			}
			String typeName = (String)columnLengthMap.get("typeName");
			int columnSize = (Integer)columnLengthMap.get("columnSize");
			//System.out.println(name);
			if(!("").equals(value) && value != null){
				if(valueJy(value,typeName,columnSize)){
					continue;
				}else{
					legthIndex.add(i+1);
				}
			}else{
				continue;
			}
			
		}
		return legthIndex;
	}
	
	private boolean valueJy(String value,String typeName,int columSize){
		try{
			if(typeName.equals("int")||typeName.equals("integer")){
				double num = Double.valueOf(value);
				if(num>Math.pow(-2, 31)&&num<(Math.pow(2, 31)-1)){
					return true;
				}else{
					return false;
				}
			}else if(typeName.equals("numeric")||typeName.equals("decimal")||typeName.equals("number")){
				double num = Double.valueOf(value);
				if(num>Math.pow(-2, columSize*8-1)&&num<(Math.pow(2, columSize*8-1)-1)){
					return true;
				}else{
					return false;
				}
			}else if(typeName.equals("date")||typeName.equals("datetime")){
					return DateConvert.checkDate(value);
			}else{
				if(value.getBytes().length<=columSize){
					return true;
				}else{
					return false;
				}
			}
		}catch(Exception e){
			System.out.println("------------>有错误!");
			e.printStackTrace();
			return false;
		}
	}
	
}
